import com.sun.org.apache.xpath.internal.operations.Mod;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Stream;

/**
 * 有一些机器人分布在一条无限长的数轴上，他们初始坐标用一个下标从 0 开始的整数数组 nums 表示。当你给机器人下达命令时，它们以每秒钟一单位的速度开始移动。
 * <p>
 * 给你一个字符串 s ，每个字符按顺序分别表示每个机器人移动的方向。'L' 表示机器人往左或者数轴的负方向移动，'R' 表示机器人往右或者数轴的正方向移动。
 * <p>
 * 当两个机器人相撞时，它们开始沿着原本相反的方向移动。
 * <p>
 * 请你返回指令重复执行 d 秒后，所有机器人之间两两距离之和。由于答案可能很大，请你将答案对 109 + 7 取余后返回。
 * <p>
 * 注意：
 * <p>
 * 对于坐标在 i 和 j 的两个机器人，(i,j) 和 (j,i) 视为相同的坐标对。也就是说，机器人视为无差别的。
 * 当机器人相撞时，它们 立即改变 它们的前进方向，这个过程不消耗任何时间。
 * 当两个机器人在同一时刻占据相同的位置时，就会相撞。
 * <p>
 * 例如，如果一个机器人位于位置 0 并往右移动，另一个机器人位于位置 2 并往左移动，下一秒，它们都将占据位置 1，并改变方向。再下一秒钟后，第一个机器人位于位置 0 并往左移动，而另一个机器人位于位置 2 并往右移动。
 * <p>
 * 例如，如果一个机器人位于位置 0 并往右移动，另一个机器人位于位置 1 并往左移动，下一秒，第一个机器人位于位置 0 并往左行驶，而另一个机器人位于位置 1 并往右移动。
 * 示例 1：
 * <p>
 * 输入：nums = [-2,0,2], s = "RLL", d = 3
 * 输出：8
 * 解释：
 * 1 秒后，机器人的位置为 [-1,-1,1] 。现在下标为 0 的机器人开始往左移动，下标为 1 的机器人开始往右移动。
 * 2 秒后，机器人的位置为 [-2,0,0] 。现在下标为 1 的机器人开始往左移动，下标为 2 的机器人开始往右移动。
 * 3 秒后，机器人的位置为 [-3,-1,1] 。
 * 下标为 0 和 1 的机器人之间距离为 abs(-3 - (-1)) = 2 。
 * 下标为 0 和 2 的机器人之间的距离为 abs(-3 - 1) = 4 。
 * 下标为 1 和 2 的机器人之间的距离为 abs(-1 - 1) = 2 。
 * 所有机器人对之间的总距离为 2 + 4 + 2 = 8 。
 * 示例 2：
 * <p>
 * 输入：nums = [1,0], s = "RL", d = 2
 * 输出：5
 * 解释：
 * 1 秒后，机器人的位置为 [2,-1] 。
 * 2 秒后，机器人的位置为 [3,-2] 。
 * 两个机器人的距离为 abs(-2 - 3) = 5 。
 */
public class T2731 {

    public T2731(int[] nums, String s, int d) {

        long sum = 0;
        for (int i = 0; i < nums.length; i++) {
            for (int j = i+1;j<nums.length;j++){
                long a = 0;
                long b = 0;
                if (s.charAt(i) == 'L'){
                     a = nums[i]-d;
                }else {
                    a = nums[i]+d;
                }
                if (s.charAt(j) == 'L'){
                    b = nums[j]-d;
                }else {
                    b = nums[j]+d;
                }
                sum+=Math.abs(a-b)%100000007;
            }
        }
        System.out.println(sum);
        // 所有机器人的状态
        // key 表示位置 value 机器人数量
        Map<Integer, Integer> scene = new ConcurrentHashMap<>();
        // key 机器人标识、机器人位置
        Map<Integer, Integer> robotsP = new ConcurrentHashMap<>();
        // key 机器人标识、机器人方向
        Map<Integer, Character> robotsD = new ConcurrentHashMap<>();

        for (int i = 0; i < nums.length; i++) {
            scene.put(nums[i], 1);
            robotsP.put(i, nums[i]);
            robotsD.put(i, s.charAt(i));
        }
        for (int i = 0; i < d; i++) {
            scene = moveP(scene, robotsP, robotsD);
        }
        System.out.println(scene);
    }

    // 移动
    public Map<Integer, Integer> moveP(Map<Integer, Integer> scene, Map<Integer, Integer> robotsP, Map<Integer, Character> robotsD) {
        Map<Integer, Integer> move = new HashMap<>();

        robotsP.forEach((key, value) -> {

            // 右边移动
            if (robotsD.get(key) == 'R') {
                if (scene.get(robotsP.get(key)) == 2) {

                    if (move.containsKey(robotsP.get(key) - 1)) {
                        move.remove(robotsP.get(key) - 1);
                        move.put(robotsP.get(key) - 1, 2);
                    } else {
                        move.put(robotsP.get(key) - 1, 1);
                    }
                    // 如果当前位置存在两个机器人直接反方向移动
                    updateD(key, robotsD);
                    updateP(key, robotsP, 'L');
                } else if (scene.containsKey(robotsP.get(key) + 1) && robotsD.get(key + 1) == 'L') {
                    // 发生碰撞
                    if (move.containsKey(robotsP.get(key) - 1)) {
                        move.remove(robotsP.get(key) - 1);
                        move.put(robotsP.get(key) - 1, 2);
                    } else {
                        move.put(robotsP.get(key) - 1, 1);
                    }
                    // 修改机器人的状态
                    updateD(key, robotsD);
                    updateP(key, robotsP, 'L');

                } else {
                    if (move.containsKey(robotsP.get(key) + 1)) {
                        move.remove(robotsP.get(key) + 1);
                        move.put(robotsP.get(key) + 1, 2);
                    } else {
                        move.put(robotsP.get(key) + 1, 1);
                    }
                    // 未发生碰撞
                    // 修改机器人的状态
                    updateP(key, robotsP, 'R');
                }
            } else if (robotsD.get(key) == 'L') {
                if (scene.get(robotsP.get(key)) == 2) {
                    if (move.containsKey(robotsP.get(key) + 1)) {
                        move.remove(robotsP.get(key) + 1);
                        move.put(robotsP.get(key) + 1, 2);
                    } else {
                        move.put(robotsP.get(key) + 1, 1);
                    }
                    // 如果当前位置存在两个机器人直接反方向移动
                    updateD(key, robotsD);
                    updateP(key, robotsP, 'R');
                } else if (scene.containsKey(robotsP.get(key) + 1) && robotsD.get(key + 1) == 'R') {
                    if (move.containsKey(robotsP.get(key) + 1)) {
                        move.remove(robotsP.get(key) + 1);
                        move.put(robotsP.get(key) + 1, 2);
                    } else {
                        move.put(robotsP.get(key) + 1, 1);
                    }

                    // 修改机器人的状态
                    updateD(key, robotsD);
                    updateP(key, robotsP, 'R');
                } else {
                    if (move.containsKey(robotsP.get(key) - 1)) {
                        move.remove(robotsP.get(key) - 1);
                        move.put(robotsP.get(key) - 1, 2);
                    } else {
                        move.put(robotsP.get(key) - 1, 1);
                    }
                    // 未发生碰撞
                    // 修改机器人的状态
                    updateP(key, robotsP, 'L');
                }
            }
        });

        return move;

    }

    public void updateD(Integer key, Map<Integer, Character> robotsD) {
        if (robotsD.get(key) == 'L') {
            robotsD.remove(key);
            robotsD.put(key, 'R');
        } else {
            robotsD.remove(key);
            robotsD.put(key, 'L');
        }
    }

    public void updateP(Integer key, Map<Integer, Integer> robotsP, char D) {
        // 修改坐标
        if (D == 'L') {
            Integer current = robotsP.get(key);
            robotsP.remove(key);
            robotsP.put(key, current - 1);
        } else {
            Integer current = robotsP.get(key);
            robotsP.remove(key);
            robotsP.put(key, current + 1);
        }
    }


}
